sweetsmelon博客

go gRPC 初体验

Fri, 07 Sep 2018 00:00:00 +0800

安装 gRPC

go get google.golang.org/grpc

安装 protocal 环境

从 https://github.com/google/protobuf/releases下载安装包，例如：protobuf-cpp-3.6.1.zip，解压后

./configure make && make install

等待至安装完成

zhangqiangdeMac-mini:protobuf-3.6.1 zhqmac$ protoc --version

提示版本信息，表示安装成功

libprotoc 3.6.1

goland 安装 protoc 插件

插件名	用途
Protobuf Support	protoc文件打开工具
ClangFormatIJ	protoc 代码提示工具

安装GoLang protoc 插件

go get -a github.com/golang/protobuf/protoc-gen-go

定义Service

一个RPC service就是一个能够通过参数和返回值进行远程调用的method，我们可以简单地将它理解成一个函数。因为gRPC是通过将数据编码成protocal buffer来实现传输的。因此，我们通过protocal buffers interface definitioin language(IDL)来定义service method，同时将参数和返回值也定义成protocal buffer message类型。具体实现如下所示，包含下面代码的文件叫helloworld.proto：

syntax = "proto3";

option java_package = "io.grpc.examples";

package helloworld;

// The greeter service definition.
service Greeter {
    // Sends a greeting
    rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
    string name = 1;
}

// The response message containing the greetings
message HelloReply {
    string message = 1;
}

接着，根据上述定义的service，我们可以利用protocal buffer compiler ，即protoc生成相应的服务器端和客户端的GoLang代码。生成的代码中包含了客户端能够进行RPC的方法以及服务器端需要进行实现的接口

假设现在所在的目录是$GOPATH/src/helloworld/helloworld，我们将通过如下命令生成gRPC对应的GoLang代码：

protoc --go_out=plugins=grpc:. proto/helloworld.proto

此时，将在目录下生成helloworld.pb.go文件。

server.go

package main

// server.go

import (
	"log"
	"net"

	"golang.org/x/net/context"
	"google.golang.org/grpc"
	pb "zhqGo/gRPCDemo/proto"
)

const (
	port = ":50051"
)

type server struct {}

func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
	return &pb.HelloReply{Message: "Hello " + in.Name}, nil
}

func main() {
	lis, err := net.Listen("tcp", port)
	if err != nil {
		log.Fatal("failed to listen: %v", err)
	}
	s := grpc.NewServer()
	pb.RegisterGreeterServer(s, &server{})
	s.Serve(lis)
}

client.go

package main

//client.go

import (
	"log"
	"os"

	"golang.org/x/net/context"
	"google.golang.org/grpc"
	pb "zhqGo/gRPCDemo/proto"
)

const (
	address     = "localhost:50051"
	defaultName = "world"
)

func main() {
	conn, err := grpc.Dial(address, grpc.WithInsecure())
	if err != nil {
		log.Fatal("did not connect: %v", err)
	}
	defer conn.Close()
	c := pb.NewGreeterClient(conn)

	name := defaultName
	if len(os.Args) >1 {
		name = os.Args[1]
	}
	r, err := c.SayHello(context.Background(), &pb.HelloRequest{Name: name})
	if err != nil {
		log.Fatal("could not greet: %v", err)
	}
	log.Printf("Greeting: %s", r.Message)
}

最后运行：

go run server.go

go run client.go

以上是grpc官网给出的一个demo，如果跑通了，表示环境已经没有问题了，接下来给它改一改

添加age字段

一、打开`helloworld.proto`文件,找到

message HelloRequest{
        string name = 1;
}

请求体，暂且就这么说吧，反正就是在client端调用时需要传入的参数,添加字段

     int32 age = 2;

一些说明:

string、int32为字段的数据类型，还有其他数据类型，见下表
name = 1,age=2,其中”1,2”表示字段tag值，tag值不可以重复

.proto Type	Notes	C++ Type	Java Type
double		doubel	doubel
float		float	float
int32	Uses variable-length encoding. Inefficient for encoding negative numbers – if your field is likely to have negative values, use sint32 instead.	int32	int
int64	Uses variable-length encoding. Inefficient for encoding negative numbers – if your field is likely to have negative values, use sint64 instead.	int64	long
uint32	Uses variable-length encoding.	uint32	int
uint64	Uses variable-length encoding.	uint64	long
sint32	Uses variable-length encoding. Signed int value. These more efficiently encode negative numbers than regular int64s.	int32	int
sint64	Uses variable-length encoding. Signed int value. These more efficiently encode negative numbers than regular int32s.	int64	long
fixed32	Always four bytes. More efficient than uint32 if values are often greater than 2^28.	uint32	int
fixed64	Always eight bytes. More efficient than uint64 if values are often greater than 2^56.	uint64	long
sfixed32	Always four bytes.	int32	int
sfixed64	Always eight bytes.	int64	long
bool		bool	boolean
string	A string must always contain UTF-8 encoded or 7-bit ASCII text.	string	string
bytes	May contain any arbitrary sequence of bytes.	string	ByteString

二、添加响应字段

message HelloReply {
    string message = 1;
    //age字段
    int32 ageMessage = 2;

}

在当前工程目录下执行命令,将重新生成helloworld.pb.go

protoc –go_out=plugins=grpc:. proto/helloworld.proto

打开helloworld.pb.go,可以看到一些变化

HelloRequest结构体中多了Age字段和func (m *HelloRequest) GetAge() int32 方法
HelloReply结构体中多了AgeMessage字段和func (m *HelloReply) GetAgeMessage() int32 方法

三、调用

client.go

替换下面代码

	r, err := c.SayHello(context.Background(), &pb.HelloRequest{Name: name,Age:25})
	if err != nil {
		log.Fatal("could not greet: %v", err)
	}
	log.Printf("Greeting: %s,%v", r.Message,r.AgeMessage)

server.go

替换下面代码

func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
	return &pb.HelloReply{Message:"123",AgeMessage:in.Age}, nil
}

执行：

go run server.go go run client.go

可以看到有age输出。

protobuf repeated

message中通过repeated关键字+数据类型，声明一个数组，如声明一个int32的数组

repeated int32 array = 3

注：在go调用方法时，repeated声明的字段为切片类型

package==true

package用于修饰 ``repeated` 声明的字段

1.作用

2.只能用于基本数据类型

添加方法

一、声明方法

打开helloworld.proto文件

service Greeter {
    // Sends a greeting
    rpc SayHello (HelloRequest) returns (HelloReply) {}
    //添加ZHQTest方法
    //形参 TestRequest对象
    //返回值 TestReply对象
    rpc ZHQTest (TestRequest) returns (TestReply){}
}
message TestRequest {
    repeated string users = 1 ;
}
message TestReply{
    repeated string users = 1 ;
}

在当前工程目录下执行命令,将重新生成helloworld.pb.go

protoc –go_out=plugins=grpc:. proto/helloworld.proto

二、调用方法

server.go

//方法名必须与Greeter声明的方法名一致
func (s *server)ZHQTest(ctx context.Context, in *pb.TestRequest) (*pb.TestReply, error) {

	return &pb.TestReply{Users:in.Users},nil
}

client.go

func myRPCRequest(c pb.GreeterClient)  {
	users := []string{"zhq", "sweetsmelon"}
	r, err := c.ZHQTest(context.Background(), &pb.TestRequest{Users: users})
	if err != nil {
		log.Fatal("could not greet: %v", err)
	}
	log.Printf("users is:%v,%s", r.Users[0],r.Users[1])
}

执行：

go run server.go

go run client.go

demo下载 https://github.com/sweetMegan/gRPCDemo

参考链接：

https://www.cnblogs.com/YaoDD/p/5504881.html

https://blog.csdn.net/weiwangchao_/article/details/16797763

https://www.jianshu.com/p/30ef9b3780d9

jwt 初体验

Sat, 01 Sep 2018 00:00:00 +0800

简介

1、什么是JWT

JWT是json web token缩写。它将用户信息加密到token里，服务器不保存任何用户信息。服务器通过使用保存的密钥验证token的正确性，只要正确即通过验证。

2、JWT结构

JWT包含三部分:Header（头部）、Payload（负载）、Signature（签名）

最终生成的JWT样式:base64URLEncoding(Header).+base64URLEncoding(Payload).+HMAC-SHA256(base64URLEncoding(Header).+base64URLEncoding(Payload).+密钥)

`Header`

一般保存两部分信息：token类型和加密算法

{
    "alg":"HS256",
    "typ":"JWT"
}

经过Base64Url编码后作为JWT结构的第一部分。

`Payload`

Token的第二部分是负载，它包含了claim， Claim是一些实体（通常指的用户）的状态和额外的元数据，有三种类型的claim：reserved, public 和 private.Reserved claims: 这些claim是JWT预先定义的，在JWT中并不会强制使用它们，而是推荐使用，常用的有 iss（签发者）,exp（过期时间戳）, sub（面向的用户）, aud（接收方）, iat（签发时间）。 Public claims：根据需要定义自己的字段，注意应该避免冲突 Private claims：这些是自定义的字段，可以用来在双方之间交换信息

{ 
    "sub": "1234567890", 
    "name": "John Doe",
    "admin": true
 }

经过Base64Url编码后作为JWT结构的第二部分。

`Signature`

创建签名需要使用编码后的header和payload以及一个秘钥，使用header中指定签名算法进行签名。例如如果希望使用HMAC SHA256算法，那么签名应该使用下列方式创建： HMACSHA256( base64UrlEncode(header) + “.” + base64UrlEncode(payload), secret) 签名用于验证消息的发送者以及消息是没有经过篡改的。完整的JWT 完整的JWT格式的输出是以. 分隔的三段Base64编码，与SAML等基于XML的标准相比，JWT在HTTP和HTML环境中更容易传递。下列的JWT展示了一个完整的JWT格式，它拼接了之前的Header， Payload以及秘钥签名：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1MzU5NDgyNzMsImlhdCI6MTUzNTk0NDY3MywidXNlcm5hbWUiOiJzd2VldHNtZWxvbiJ9.cfyaGsbVrHalZik1HPPqZAttk3sjM7XY-mBhdmCSis8

如何使用JWT

使用场景：身份鉴定、信息交换

以身份鉴定为例:

在身份鉴定的实现中，传统方法是在服务端存储一个session，给客户端返回一个cookie，而使用JWT之后，当用户使用它的认证信息登陆系统之后，会返回给用户一个JWT，用户只需要本地保存该token（通常使用local storage，也可以使用cookie）即可。当用户希望访问一个受保护的路由或者资源的时候，通常应该在Authorization头部使用Bearer模式添加JWT，其内容看起来是下面这样：Authorization: Bearer 因为用户的状态在服务端的内存中是不存储的，所以这是一种无状态的认证机制。服务端的保护路由将会检查请求头Authorization中的JWT信息，如果合法，则允许用户的行为。由于JWT是自包含的，因此减少了需要查询数据库的需要。 JWT的这些特性使得我们可以完全依赖其无状态的特性提供数据API服务，甚至是创建一个下载流服务。因为JWT并不使用Cookie的，所以你可以使用任何域名提供你的API服务而不需要担心跨域资源共享问题（CORS）。下面的序列图展示了该过程：

go 实现myJWT

package main

import (
	"time"
	"encoding/json"
	"encoding/base64"
	"fmt"
	"crypto/hmac"
	"crypto/sha256"
	"strings"
)

const kScreateKey  = "123"
type Header struct {
	//加密方式
	Alg string
	//加密类型
	Typ string
}
type Payload struct {
	//过期时间
	Exp int64
	//签发时间
	Iat int64
	//用户名
	UserName string
}

type jwt struct {
	Header Header
	Payload Payload
	Signature string
}

func main() {
	token := createToken()
	//token := "eyJBbGciOiJIUzI1NiIsIlR5cCI6IkpXVCJ9.eyJFeHAiOjE1MzU5NDk5MjUsIklhdCI6MTUzNTk0OTkyMywiVXNlck5hbWUiOiJzd2VldHNtZWxvbiJ9.C6XqHbR3Td9PhgTofVGlLnQ6PAab2pHm9T7yj_NtoQs"
	verifyToken(token)
}
//创建token
func createToken() string {

	//1、创建header
	header := Header{"HS256","JWT"}
	//2、创建JWT第一段 header的base64编码
	headerBytes,err := json.Marshal(header)
	fmt.Println(err)
	header_Base64 := base64.URLEncoding.EncodeToString(headerBytes)
	//3、创建payload
	payload := Payload{}
	//token两秒后过期
	payload.Exp = time.Now().Add(time.Second*time.Duration(2)).Unix()
	payload.Iat = time.Now().Unix()
	payload.UserName = "sweetsmelon"
	//4、创建JWT第二段 payload的base64编码
	payloadBytes,_:= json.Marshal(payload)
	payload_Base64 := base64.URLEncoding.EncodeToString(payloadBytes)

	//5、拼接header和payload
	hpString := fmt.Sprintf("%s.%s",header_Base64,payload_Base64)
	//6、生成签名
	signatureStr := createSianature(hpString)
	token := fmt.Sprintf("%s.%s",hpString,signatureStr)
	fmt.Println(token)

	return token
}
func createSianature(hpString string) string  {
	hasher := hmac.New(sha256.New,[]byte(kScreateKey))
	hasher.Write([]byte(hpString))
	signatureStr :=strings.TrimRight(base64.URLEncoding.EncodeToString(hasher.Sum(nil)), "=")
	return signatureStr
}
func verifyToken(token string)  {
	//1、根据"."拆分token
	jwt := strings.Split(token,".")
	//2、解析header
	headerStr := jwt[0]
	headerBytes,_ := base64.URLEncoding.DecodeString(headerStr)
	header := Header{}
	json.Unmarshal(headerBytes,&header)
	//3、解析payload
	payloadStr := jwt[1]
	payloadBytes,_ := base64.URLEncoding.DecodeString(payloadStr)
	payload := Payload{}
	json.Unmarshal(payloadBytes,&payload)
	//4、验证签名是否有效
	hpString := fmt.Sprintf("%s.%s",headerStr,payloadStr)
	signatureString := createSianature(hpString)
	if signatureString == jwt[2] {
		if header.Alg == "HS256" && header.Typ == "JWT" {
			//3、判断是否过期
			if payload.Exp < time.Now().Unix() {
				fmt.Println("验证码已失效")
			}else {
				fmt.Println("验证成功 username=",payload.UserName)
			}
		}else {
			fmt.Println("验证header失败")
		}
	}else {
		fmt.Println("验证签名失败")
	}
}

使用 jwt-go

jwt-go是一个封装好的go语言版的jwt工具

安装`jwt-go`

go get github.com/dgrijalva/jwt-go

使用

package main

import (
	"time"
	"github.com/dgrijalva/jwt-go"
	"reflect"
	"fmt"
)
const kSecretKey = "123456"
func main() {
	createToken()
}
func createToken() {
	token := jwt.New(jwt.SigningMethodHS256)
	claims := make(jwt.MapClaims)
	claims["exp"] = time.Now().Add(time.Hour * time.Duration(1)).Unix()
	claims["iat"] = time.Now().Unix()
	//自定义属性username
	claims["username"] = "sweetsmelon"
	token.Claims = claims

	tokenString, err := token.SignedString([]byte(kSecretKey))
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(tokenString)
	veiftyToken(tokenString)
}
func veiftyToken(tokenStr string)  {
	token, err := jwt.Parse(tokenStr, func(token *jwt.Token) (interface{}, error) {
		return []byte(kSecretKey), nil
	})
	//通过映射，获取自定义的Claims属性
	switch token.Claims.(type) {
	case jwt.MapClaims:
		{
			v := reflect.ValueOf(token.Claims)
			v2 := v.Interface().(jwt.MapClaims)
			fmt.Println(v2["username"])
			if err != nil {
				fmt.Println("验证失败")
			} else {
				if token.Valid {
					fmt.Println("验证成功")
				} else {
					fmt.Println("验证码失效")
				}
			}
			return
		}
	}
	fmt.Println("token格式错误，验证失败")
}

参考资料：

https://jwt.io/introduction/

https://blog.csdn.net/qq_40081976/article/details/79046825

http://blog.51cto.com/xwandrew/2050973

go iris 实现GET、POST、PUT接口

Sat, 01 Sep 2018 00:00:00 +0800

Iris自称是Go语言中所有Web框架最快的，它的特点如下：

聚焦高性能
健壮的静态路由支持和通配符子域名支持。
视图系统支持超过5以上模板
支持定制事件的高可扩展性Websocket API
带有GC, 内存 & redis 提供支持的会话
方便的中间件和插件
完整 REST API
能定制 HTTP 错误
Typescript编译器 + 基于浏览器的编辑器
内容 negotiation & streaming
传送层安全性
源码改变后自动加载
OAuth, OAuth2 支持27+ API providers
JSON Web Tokens

使用 iris 实现 REST API

安装Iris

go get github.com/kataras/iris

一、GET

1.不需要传参的`GET`接口

package main

import "github.com/kataras/iris"

func main() {
	//获取一个iris对象
	app := iris.New()
	//绑定路由/login，访问后输出LOGIN
	app.Handle("GET","/login", func(ctx iris.Context) {
		ctx.JSON("LOGIN")
	})
	//在8080端口启动服务
	app.Run(iris.Addr(":8080"))
}

执行代码,浏览器访问http://localhost:8080/login,如果没有问题，窗口将会显示"LOGIN"

2.需要传参的`GET`接口

package main

import (
	"github.com/kataras/iris"
	"fmt"
)

func main() {
	//获取一个iris对象
	app := iris.New()
	//绑定路由/login/{用户名}/{密码}，访问后输出用户名，密码
	app.Handle("GET", "/login/{username}/{password}", func(ctx iris.Context) {
		//获取参数值
		username := ctx.Params().Get("username")
		fmt.Println(username)
		password := ctx.Params().Get("password")
		fmt.Println(password)
		data := &struct {
			Username string
			Password string
		}{
			Username: username,
			Password: password,
		}
		ctx.JSON(data)
	})
	//在8080端口启动服务
	app.Run(iris.Addr(":8082"))
}

iris中GET接口传参采用{}加key值的方式获取参数通过ctx.Params().Get(key)

执行代码,浏览器访问http://localhost:8082/login/zhq/123,如果没有问题，窗口将会显示{"password":"123","username":"zhq"}

二、POST

1.接收的是字符串的处理

func postAPI(app *iris.Application)  {
	//绑定路由/login/{用户名}/{密码}，访问后输出用户名，密码
	app.Handle("POST", "/regist", func(ctx iris.Context) {
		//获取参数值
		username := ctx.FormValue("username")
		fmt.Println("==",username)
		password := ctx.FormValue("password")
		fmt.Println(password)
		data := &struct {
			Username string
			Password string
		}{
			Username: username,
			Password: password,
		}
		ctx.JSON(data)
	})
}

执行代码,打开终端执行curl命令模拟POST请求

zhangqiangdeMac-mini:~ zhqmac$ curl localhost:8080/regist -d ‘user=zhq&password=123456’ -X POST

输出结果:

{“Username”:””,”Password”:”123456”}

2.接收的是`JSON`数据的处理

func postAPI_2(app *iris.Application)  {
	//绑定路由/login/{用户名}/{密码}，访问后输出用户名，密码
	app.Handle("POST", "/regist", func(ctx iris.Context) {
		data := &struct {
			Username string `json:"username"`
			Password string `json:"password"`
		}{}
		//读取JSON数据
		ctx.ReadJSON(data)
		fmt.Println(data.Username,"==",data.Password)
		ctx.JSON(data)
	})
}

执行代码,打开终端执行curl命令模拟POST请求

zhangqiangdeMac-mini:~ zhqmac$ curl -H “Content-Type:application/json” -X POST –data ‘{“username”:”zhq”,”password”:”123456”}’ http://localhost:8080/regist

运行结果:

{“username”:”zhq”,”password”:”123456”}

三、PUT

PUT和POST在技术实现上是没有很大区别的。在上面的代码中将POST改成PUT即可，但在于协议上语义是很大区别的。

1.`POST`

用于提交请求，可以更新或者创建资源，是非幂等的

举个例子，在我们的支付系统中，一个api的功能是创建收款金额二维码，它和金额相关，每个用户可以有多个二维码，如果连续调用则会创建新的二维码，这个时候就用POST

2.`PUT`

用于向指定的URI传送更新资源，是幂等的

还是那个例子，用户的账户二维码只和用户关联，而且是一一对应的关系，此时这个api就可以用PUT，因为每次调用它，都将刷新用户账户二维码

3.什么是幂等

对于单目运算，如果一个运算对于在范围内的所有的一个数多次进行该运算所得的结果和进行一次该运算所得的结果是一样的，那么我们就称该运算是幂等的。比如绝对值运算就是一个例子，在实数集中，有abs(a) = abs(abs(a)) 。　　对于双目运算，则要求当参与运算的两个值是等值的情况下，如果满足运算结果与参与运算的两个值相等，则称该运算幂等，如求两个数的最大值的函数，有在在实数集中幂等，即max(x,x) = x

4.当需要以更新的形式来修改某一具体资源的时候，如何判断用PUT还是POST呢？

很简单，如果该更新对应的URI多次调用的结果一致，则PUT

比如更新某个blog文章，因为该文章具有单一的具体URI，所以每次更新提交相同的内容，结果都一致

/blog/{document_id}/update

在每次更新提交相同的内容，最终的结果不一致的时候，用POST

举个很常见的例子，一个接口的功能是将当前余额减一个值，每次提交指定该值为100，接口如下

/amount/deduction

调用一次，你的余额-100，调用两次，余额-200

这个时候就用POST

demo下载 https://github.com/sweetMegan/irisDemo

参考资料：

https://my.oschina.net/liujiest/blog/738992

https://my.oschina.net/u/1263964/blog/268932

https://baike.baidu.com/item/URI/2901761?fr=aladdin

go 发送邮件

Sat, 01 Sep 2018 00:00:00 +0800

简述

Go 提供了一个 smtp（Simple Mail Transfer Protocol - 简单邮件传输协议）库作为其网络包的一部分，“net/smtp”公开了一些可立即使用的有用功能。

Gomail - 一个比较成熟的第三方包，提供了一个快速、简单的解决方案，可以轻松地发送电子邮件。

SMPT

SMTP（Simple Mail Transfer Protocol）即简单邮件传输协议,它是一组用于由源地址到目的地址传送邮件的规则，由它来控制信件的中转方式。SMTP协议属于TCP/IP协议簇，它帮助每台计算机在发送或中转信件时找到下一个目的地。通过SMTP协议所指定的服务器,就可以把E-mail寄到收信人的服务器上了，整个过程只要几分钟。SMTP服务器则是遵循SMTP协议的发送邮件服务器，用来发送或中转发出的电子邮件。

实例

1.导入`gomail`

go get “github.com/go-gomail/gomail”

2.demo

package main

import (
	"bytes"
	"fmt"
	"github.com/go-gomail/gomail"
	"html/template"
)

func main() {
	m := gomail.NewMessage()
	//发件人邮箱
	fromEmail := "123456@qq.com"

	//发件人昵称
	fromName := "zhq"
	m.SetAddressHeader("From", fromEmail, fromName) // 发件人
	//收件人邮箱
	toEmail := "67890@163.com"

	m.SetHeader("To", // 收件人
		m.FormatAddress(toEmail, ""),
	)
	m.SetHeader("Subject", "发送邮件测试")            // 主题
	//初始化模板
	emailTemplate := `<div></div>`
	t, err := template.New("mail summary template").Parse(emailTemplate)
	if err != nil {
		fmt.Println(err)
	}
	buffer := new(bytes.Buffer)
	data := &struct{
		Vcode string
	}{
		Vcode:"hello world",
	}
	//动态配置模板
	t.Execute(buffer,data)
	// 正文
	m.SetBody("text/html", buffer.String())
	//发件人邮箱授权码
	fromEmailPassword := "123"
	d := gomail.NewDialer("smtp.qq.com", 465, fromEmail, fromEmailPassword)
	if err := d.DialAndSend(m); err != nil {
		fmt.Println(err)
	}
	fmt.Println("邮件已发送")
}

ps:需要注意的是 d := gomail.NewDialer(“smtp.qq.com”, 465, fromEmail, fromEmailPassword) 中 fromEmailPassword并非邮箱密码，而是授权码

执行代码，如果输出邮件已发送表示邮件发送成功，查看收件人邮箱即可

3.获取授权码,以qq邮箱为例

进入邮箱 -> 设置 -> 账户 -> POP3/IMAP/SMTP/Exchange/CardDAV/CalDAV服务 -> 开启POP3/SMTP服务

常用邮箱

列举一些常用的邮箱，可以用来测试：

QQ 邮箱 POP3 服务器地址：qq.com（端口：995） SMTP 服务器地址：smtp.qq.com（端口：465/587）

163 邮箱： POP3 服务器地址：pop.163.com（端口：110） SMTP 服务器地址：smtp.163.com（端口：25）

126 邮箱： POP3 服务器地址：pop.126.com（端口：110） SMTP 服务器地址：smtp.126.com（端口：25）

参考资料:

https://blog.csdn.net/liang19890820/article/details/53084638

https://blog.csdn.net/wangshubo1989/article/details/70808989

go test使用

Thu, 02 Aug 2018 00:00:00 +0800

go test 功能，提高了开发和测试的效率。

下面例子的文件结构如下：

goTest使用/add.go goTest使用/test_add.go

add.go

package goTest使用

import "fmt"

func Add(a, b int) int {
	return a+b
}
func What() {
fmt.Println("what ?")
}

add_test.go

package goTest使用

import (
	"testing"
	"fmt"
)

func TestAdd(t *testing.T) {
	r := Add(1,2)
	fmt.Println(r)

}
func TestWhat(t *testing.T) {
	What()
}

进入两个文件所在的目录下,如

zhangqiangdeMac-mini:Test zhqmac$ cd goTest使用/

执行 go test命令

zhangqiangdeMac-mini:goTest使用 zhqmac$ go test

控制台输出:

3  //Add()结果
what ? //What()结果
PASS
ok      zhqGo/Test/goTest使用   0.007s

测试某个函数

go test 命令，默认运行所有在目录下xxx_test.go 的测试文件而且只对以Testxxx(t tesing.T)的函数进行测试,要单测某个函数,如Add()可以使用命令

go test -test.run Add

或

go test -test.run TestAdd

测试单个文件

go test -v add_test.go add.go

测试前初始化

进行测试之前需要初始化操作(例如打开连接)，测试结束后，需要做清理工作(例如关闭连接)等等。这个时候就可以使用TestMain()。

package goTest使用

import (
	"testing"
	"fmt"
)

func TestAdd(t *testing.T) {
	r := Add(1,2)
	fmt.Println(r)

}
func TestWhat(t *testing.T) {
	What()
}
func TestMain(m *testing.M)  {
//初始化操作
	fmt.Println("begin")
	m.Run()
	fmt.Println("end")
}

参数说明

1、运行参数

go test 忽略log信息
go test -v 冗长模式，打印实时的log信息

2、测试过程控制

t.Log t.Logf // 正常信息
t.Error t.Errorf // 测试失败信息
t.Fatal t.Fatalf // 致命错误，测试程序退出的信息
t.Fail //当前测试标记为失败
t.Failed //查看失败标记
t.FailNow// 标记失败，并终止当前测试函数的执行(需要注意的是，我们只能在运行测试函数的Goroutine中调用 //t.FailNow方法，而不能在我们在测试代码创建出的Goroutine中调用它。
t.Skip //调用t.Skip方法相当于先后对t.Log和t.SkipNow方法进行调用，而调用t.Skipf方法则相当于先后对 //t.Logf和t.Skip-Now方法进行调用。方法t.Skipped的结果值会告知我们当前的测试是否已被忽略。
t.Parallel // 标记为可并行运算

参考资料

go test 初始化— TestMain的使用
https://www.cnblogs.com/lanyangsh/p/8685989.html

go defer、panic、recover使用

Thu, 02 Aug 2018 00:00:00 +0800

defer

defer和go一样都是Go语言提供的关键字。defer用于资源的释放，会在函数返回之前进行调用。

多个defer调用顺序

如果有多个defer表达式，调用顺序类似于栈，越后面的defer表达式越先被调用。

func f() {
	defer fmt.Println("defer 1")
	defer fmt.Println("defer 2")
	defer fmt.Println("defer 3")
}
执行结果为：
defer 3
defer 2
defer 1

defer函数形参的值

如果defer函数需要外界传参，形参的值，在defer函数定义时形参就已经被赋值。

func f() {
	i := 1
	defer func(i int) {
		fmt.Println("defer ", i)

	}(i) //i = 1
	i++
	defer func(i int) {
		fmt.Println("defer ", i)
	}(i) //i = 2
	i++
	defer func(i int) {
		fmt.Println("defer ", i)
	}(i)//i = 3
	i++
	defer func(i int) {
		fmt.Println("defer ", i)
	}(i) //i = 4
}

执行结果:
defer  4
defer  3
defer  2
defer  1

defer,return的执行顺序

先看两段代码代码1：

func main() {
	fmt.Println("b return:", b()) // 打印结果为 b return: 2
}

func b() (i int) {
	defer func() {
		i++
		fmt.Println("b defer2:", i) // 打印结果为 b defer2: 2
	}()
	defer func() {
		i++
		fmt.Println("b defer1:", i) // 打印结果为 b defer1: 1
	}()
	return i // 或者直接 return 效果相同
}

代码2：

func main() {
	fmt.Println("a return:", a()) // 打印结果为 a return: 0
}

func a() int {
	var i int
	defer func() {
		i++
		fmt.Println("a defer2:", i) // 打印结果为 a defer2: 2
	}()
	defer func() {
		i++
		fmt.Println("a defer1:", i) // 打印结果为 a defer1: 1
	}()
	return i
}

两段代码区别在于，a()声明了返回值,b()返回值是匿名的代码执行结果；

a()返回值为 0
b()返回值为 2

依据结果，先来假设出结论（这是正确结论），帮助大家理解原因：

多个defer的执行顺序为“后进先出”；
所有函数在执行RET返回指令之前，都会先检查是否存在defer语句，若存在则先逆序调用defer语句进行收尾工作再退出返回；
匿名返回值是在return执行时被声明，有名返回值则是在函数声明的同时被声明，因此在defer语句中只能访问有名返回值，而不能直接访问匿名返回值；
return其实应该包含前后两个步骤：第一步是给返回值赋值（若为有名返回值则直接赋值，若为匿名返回值则先声明再赋值）；第二步是调用RET返回指令并传入返回值，而RET则会检查defer是否存在，若存在就先逆序插播defer语句，最后RET携带返回值退出函数；

‍‍因此，defer、return、返回值三者的执行顺序应该是：return最先给返回值赋值；接着defer开始执行一些收尾工作；最后RET指令携带返回值退出函数。

验证结论

func main() {
	c:=c()
	fmt.Println("c return:", *c, c) // 打印结果为 c return: 2 0xc082008340
}

func c() *int {
	var i int
	defer func() {
		i++
		fmt.Println("c defer2:", i, &i) // 打印结果为 c defer2: 2 0xc082008340
	}()
	defer func() {
		i++
		fmt.Println("c defer1:", i, &i) // 打印结果为 c defer1: 1 0xc082008340
	}()
	return &i
}

虽然 c() *int 的返回值没有被提前声明，但是由于 c() *int 的返回值是指针变量，那么在return将变量 i 的地址赋给返回值后，defer再次修改了 i 在内存中的实际值，因此return调用RET退出函数时返回值虽然依旧是原来的指针地址，但是其指向的内存实际值已经被成功修改了。

即，我们假设的结论是正确的！

defer的作用域

defer只对当前协程有效（main可以看作是主协程）；
当panic发生时依然会执行当前（主）协程中已声明的defer，但如果所有defer都未调用recover()进行异常恢复，则会在执行完所有defer后引发整个进程崩溃；
主动调用os.Exit(int)退出进程时，已声明的defer将不再被执行。

panic、recover

Go语言不支持传统的 try…catch…finally 这种异常，在go中通过defer, panic, recover来处理异常。

panic

当panic发生时依然会执行当前（主）协程中已声明的defer，但如果所有defer都未调用recover()进行异常恢复，则会在执行完所有defer后引发整个进程崩溃；

代码1：

func main() {
	ch := make(chan int)
	go func() {
	defer func() {
		ch <- 1
	}()
	panic("ss")
	}()
	<-ch
	fmt.Println("main 执行结束")
}

当程序执行到panic("ss")进程崩溃， fmt.Println("main 执行结束")可能会执行，也可能不会被执行。因为defer执行完之后，主线程继续执行，可能这时进程并未崩溃。

代码2：

	ch := make(chan int)
	go func() {
	defer func() {

		if err := recover(); err != nil {
			fmt.Println("recover")
			ch<-1

		}
	}()
	panic("ss")
	}()
	<-ch
	fmt.Println("main 执行结束")

通过recover捕获异常，并对异常进行处理，程序正常运行

网络应答异常处理

type result struct {
	code int
	msg  string
}
func main() {
	
	defer func() {
		if res := recover(); res != nil {
			r, ok := res.(*result)
			if ok {
				fmt.Println(r.msg)
				fmt.Println(r.code)
			}
		}
	}()

	panic(&result{1, "除数不能为0"})

}

参考资料

Golang中defer、return、返回值之间执行顺序的坑:
https://my.oschina.net/henrylee2cn/blog/505535

以太坊私网建立-通过创世区块来初始化区块链

Sun, 15 Jul 2018 00:00:00 +0800

一、创建目录`privatechain`,名字随便起

zhangqiangdeMac-mini:~ zhqmac$ cd Desktop

zhangqiangdeMac-mini:Desktop zhqmac$ mkdir privatechain

zhangqiangdeMac-mini:Desktop zhqmac$ cd privatechain/

二、创建创世块

vi genesis.json

拷贝下面的内容

{
  "alloc" : {},
  "coinbase" : "0x0000000000000000000000000000000000000000",
  "config" : {
    "chainId" : 110,
    "eip155Block" : 0,
    "eip158Block" : 0,
    "homesteadBlock" : 0
  },
  "difficulty" : "0x20000",
  "extraData" : "",
  "gasLimit" : "0x2fefd8",
  "mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
  "nonce" : "0x0000000000000042",
  "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
  "timestamp" : "0x00"
}

保存退出

参数说明:

参数	说明
mixhash	与nonce配合用户挖矿，由上一个区块的一部分生成的hash。
nonce	nonce就是一个64位随机数，用于挖矿
difficulty	设置当前区块的难度，如果难度过大，cpu挖矿就很难，这里设置较小难度
alloc	用来预置账号以及账号的以太币数量,因为私有链挖矿比较容易，所以我们不需要预置有币的账号，需要的时候自己创建即可以
coinbase	矿工的账号，随便填
timestamp	设置创世块的时间戳
parentHash	上一个区块的hash值，因为是创世块，所以这个值是0
extraData	附加信息，随便填，可以填你的个性信息
gasLimit	该值设置对GAS的消耗总量限制，用来限制区块能包含的交易信息总和，因为我们是私链，所以随意写

三、初始化区块链，并且创建一个文件夹来存储区块数据

zhangqiangdeMac-mini:privatechain zhqmac$ geth init genesis.json --datadir blockchainData

四、启动私有链节点

geth --datadir blockchainData/ --networkid 110 --rpc console

如果出现Welcome to the Geth JavaScript console!表示启动成功

参数	说明
identity	区块链的标示，随便填写，用于标示目前网络的名字
init	指定创世区块文件的位置，并创建初始块
datadir	设置当前区块链网络数据存放的位置
port	网络监听端口
rpc	启动rpc通信，可以进行智能合约的部署和调试
rpcapi	设置允许链接的rpc的客户端，一般为db,eth,net,web3
networkid	设置当前区块链的网络ID,用于区分不同的网络，是个数字，`1`表示主网
console	启动命令行模式，可以在`geth`中执行命令.

五、新建账户

查看所有账户

personal.listAccounts

返回为[],此时还没有账户

新建账户

personal.newAccount(“123456”)

"123456"为账户密码

personal.listAccounts

可以查看到刚才创建的钱包地址,在blockchainData目录下的keystore目录中多了一个keystore文件，里面保存的即是次账号的一些信息:

{"address":"0a778959e98293bdc1101ec211dbc3135be2b59a","crypto":{"cipher":"aes-128-ctr","ciphertext":"e6e5c00cd34e76f4d64b07f0de100f3a81cfbe8b11b3c7ffc52f7bdad6308a27","cipherparams":{"iv":"498e15f6d7244bab299ff986e4155b2b"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"5b0345890294ee5fc050b00e852963ce41cc60ae69ff86302d1a361498b09ba5"},"mac":"2e7f9c197ed4dbb9c5c3888b28639f5d38767ab3bb3359f4b58dc195d9798f2f"},"id":"a1b23559-f59e-44df-a32d-92f6682fd86f","

六、挖矿

查看账户余额

eth.getBalance(eth.coinbase)

查询结果为0，eth.coinbase矿工的账号，默认为personal.listAccounts第一个账号

设置coinbase

eth.setEtherbase(eth.accounts[0])

因为此时我们只有一个账号，如果想要设置其他账号为挖矿账号，可以新建一个账号，通过eth.accounts[index]来设置，或者直接将地址填在这里eth.setEtherbase("0x0a778959e98293bdc1101ec211dbc3135be2b59a")

开始挖矿

miner.start(1)

1表示线程数

如果卡在

INFO [07-24|00:48:46.606] Commit new mining work                   number=2 txs=0 uncles=0 elapsed=129.846µs

没有关系，等着就好，根据电脑性能不同，时间可长可短

停止挖矿

miner.stop()

输入可能被挖矿的输出截断，没关系，直接输完，回车就好

看下余额

eth.getBalance(eth.coinbase)

这时就应该有以太币了，单位为wei

七、发送交易

创建一个账号

personal.newAccount(“123456”)

解锁账号

personal.unlockAccount(eth.coinbase)

输入密码

如下输出表示解锁成功

Unlock account 0x0a778959e98293bdc1101ec211dbc3135be2b59a
Passphrase: 
true
>

注：解锁的账号，为了安全，一段时间后会自动上锁

转账

eth.sendTransaction({from:eth.coinbase,to:eth.accounts[1],value:100000000})

返回结果:

 > eth.sendTransaction({from:eth.coinbase,to:eth.accounts[1],value:100000000})
INFO [07-24|01:00:53.132] Submitted transaction                    fullhash=0xa0517620c64f43e50db46836449a18afcf749200aaa13e5ce8f17b2d86be7b4a recipient=0x19BD3Fe6E7Db24aDaA5Dc012a154A9a03dCCD1fE
"0xa0517620c64f43e50db46836449a18afcf749200aaa13e5ce8f17b2d86be7b4a"

0xa0517620c64f43e50db46836449a18afcf749200aaa13e5ce8f17b2d86be7b4a为交易hash

或者

amount = web3.toWei(10,’ether’) eth.sendTransaction({from:eth.coinbase,to:eth.accounts[1],value:amount})

查看eth.accounts[1]的余额

eth.getBalance(eth.accounts[1])

余额还是0,因为交易还没有被验证，需要矿工挖矿确认。

miner.start() miner.stop()

再查看余额

eth.getBalance(eth.accounts[1])

转账成功

八、查看交易

eth.getTransaction(“0xa0517620c64f43e50db46836449a18afcf749200aaa13e5ce8f17b2d86be7b4a”)

可以查看交易信息。

九、查看当前区块总数

eth.blockNumber

十、通过区块号查看区块

eth.getBlock(6)

十一、交易池状态

txpool.status

Nodejs实现以太坊钱包

Sun, 15 Jul 2018 00:00:00 +0800

一、创建项目

zhangqiangdeMac-mini:~ zhqmac$ mkdir myWallet

zhangqiangdeMac-mini:~ zhqmac$ cd myWallet

zhangqiangdeMac-mini:myWallet zhqmac$ npm init

将下面的依赖添加到生成的package.json文件中

 "dependencies": {
    "bignumber.js": "^7.2.1",
    "ejs": "^2.6.1",
    "koa": "^2.5.2",
    "koa-body": "^4.0.4",
    "koa-bodyparser": "^4.2.1",
    "koa-router": "^7.4.0",
    "koa-static": "^5.0.0",
    "koa-views": "^6.1.4",
    "web3": "^1.0.0-beta.34"
  }

安装依赖

npm install

二、初始化项目

新建文件index.js,项目入口
新建目录controller,封装请求处理
- account.js 与账户相关的处理
- createAccount.js创建账户处理
- transaction.js 与交易相关的处理
新建目录model,模型封装 * responsedata.js,封装应答响应对象
新建目录routers,路由处理
- router.js
新建目录utils，工具
- myUtils.js

三、响应对象

responsedata.js

function response(code, msg, data) {
    this.code = code;//状态码
    this.msg = msg;//状态描述
    this.data = data;//返回的数据
}
module.exports = response;

四、开启服务

index.js

const Koa = require("koa");
const app = new Koa();
const koaBody = require("koa-body");
const router = require("./routers/router");
app.use(async (ctx, next) => {
    console.log(`Process ${ctx.request.method} ${ctx.request.url} ...`);
    await next();
});
//解析post请求
app.use(koaBody({
    multipart:true,
}));
app.use(router.routes());
app.listen("3000");
console.log("服务已开启,监听端口:3000");

五、设置路由

router.js

const router = require("koa-router")();
const createAccountController = require("../controller/createAccount");
const accountController = require("../controller/account");
const transactionController = require("../controller/transaction");
//创建账号
router.post("/createaccount",createAccountController.createAccount);
//私钥解锁账户
router.post("/unlockaccountwithprivatekey",accountController.unlockAccountWithPrivateKey);
//keystore解锁账户
router.post("/unlockaccountwithkeystore",accountController.unlockAccountWithKeyStore);
//发起交易
router.post("/createtransaction",transactionController.createTransaction);
//确认交易
router.post("/sendtransaction",transactionController.sendTransaction);
//交易详情
router.post("/transactionstatus",transactionController.transactionStatus);
module.exports = router;

项目中所有请求都采用post的方式

六、实例化`web3`

myUtils.js

const Web3 = require("web3");
var fs = require("fs");
getWeb3 = ()=>{
    //初始化web3访问节点为私有链节点
    const web3 = new Web3(Web3.givenProvider||"http://localhost:8545");
    //以太坊测试链
    // const web3 = new Web3(Web3.givenProvider || "https://kovan.infura.io/v3/4abf7f8865064ed6b99ca3fdac820921");
    return web3;
};
module.exports={
    getWeb3,
};

调用getWeb3()获取web3对象

var web3 = new Web3(Web3.givenProvider||"http://localhost:8545");

第一次调用getWeb3()方法时Web3.givenProvider为空,所以需要设置一个种子节点。
http://localhost:8545为本地私有链地址，怎么搭建私链
https://kovan.infura.io/v3/4abf7f8865064ed6b99ca3fdac820921是以太网kovan测试链地址

获取测试链地址

打开 INFURA https://infura.io/dashboard 注册，登录登录成功后来到下面页面

可以看到主网和其他三个测试链，按需选择ENDPOINT下的地址就是我们所需要的地址

七、请求处理

在执行下面操作前需开启一个私链或者测试链

1、创建账户

createAccount.js

const web3 = require("../utils/myUtils").getWeb3();
const path = require("path");
const fs = require("fs");
var respones = require("../model/responsedata");
//创建钱包
createAccount = async ctx => {
    var responseData = new respones(0,"success",{});
    // console.log(ctx.request.body);
    var body = ctx.request.body;
    //创建钱包
    var account = web3.eth.accounts.create();
    //生成keyStore文件
    //keyStore是将私钥与用户密码拼接,将拼接结果对称加密得到
    var keyStoreJson = account.encrypt(body.pwd);
    //保存keyStore
    //写入文件的keyStore数据
    // var keyStoreStr = JSON.stringify(keyStoreJson);
    // //keyStore文件名
    // var keyStoreFileName = "UTC--"+new Date().toISOString()+"--"+account.address;
    // //文件保存路径
    // var keyStoreFilePath = path.join(__dirname,"../static/keystore",keyStoreFileName);
    // await fs.writeFile(keyStoreFilePath,keyStoreStr,()=>{});
    // var responseData = new respones(0,"success",{
    //     "downloadUrl":"/keystore/"+keyStoreFileName,
    //     "privateKey":account.privateKey
    // });
    responseData.data.keyStore = keyStoreJson;
    ctx.body = responseData;
};
module.exports={
    createAccount
};

keystore文件在客户端自己保存，服务端不保存

2、账号操作

account.js


const web3 = require("../utils/myUtils").getWeb3();
const myUtil = require("../utils/myUtils");
var response = require("../model/responsedata");
setResponseDataWithAccount = async(account, responseData)=> {
    responseData.data.address = account.address;
    responseData.data.privateKey = account.privateKey;
    responseData.data.balance = await getBalanceWithAddress(account.address);
    return responseData;
};

getBalanceWithAddress = async(address)=> {
    console.log("account:" + address);
    var balance = await web3.eth.getBalance(address);
    return web3.utils.fromWei(balance, "ether");
};
//使用私钥解锁账户
unlockAccountWithPrivateKey = async(ctx)=> {
    var responseData = new response(0, "success", {});
    var body = ctx.request.body;
    var privateKey = body.privateKey;
    console.log("privateKey:" + privateKey);
    var account = web3.eth.accounts.privateKeyToAccount(privateKey);
    // ctx.body = {name:"解锁"};
    var data = await setResponseDataWithAccount(account, responseData);
    console.log(data);
    ctx.body = data;
};
//使用keyStore文件
unlockAccountWithKeyStore = async(ctx)=> {
    var responseData = new response(0, "success", {});
    var body = ctx.request.body;
    var pwd = body.pwd;
    var keyStore = body.keyStore;
    try {
        var account = web3.eth.accounts.decrypt(keyStore, pwd);
        ctx.body = await setResponseDataWithAccount(account, responseData);
    }catch (error){
        console.log(error)
        responseData.code = 1;
        responseData.message = "failed";
        responseData.data = {error: error.message};
        ctx.body = responseData;
    }
};
module.exports = {
    unlockAccountWithPrivateKey,
    unlockAccountWithKeyStore,
};

3、交易处理

transaction.js

const web3 = require("../utils/myUtils").getWeb3();
var response = require("../model/responsedata");
var bignumber = require("bignumber.js")

//发起交易
createTransaction = async(ctx)=> {
    console.log("createTransaction");
    var responseData = new response(0, "success", {});
    var body = ctx.request.body;
    var fromAddress = body.from;
    var toAddress = body.to;
    //将输入的金额换算成Wei
    var money = web3.utils.toWei(body.money, "ether");
    var gasPrice = await web3.eth.getGasPrice();
    //获取交易的nonce值,一个顺序累加的值
    var nonce = await web3.eth.getTransactionCount(fromAddress);
    var transactionData = {
        from: fromAddress,
        to: toAddress,
        value: money,
        gasPrice: gasPrice,
        data: '0x00',//当使用代币转账或者合约调用时
        nonce: nonce,
    };
    //estimateGas()方法会将transactionData数据做一些操作,导致,transactionData一些值的类型变化,所以下面对transactionData重新赋值
    var gas = await web3.eth.estimateGas(transactionData);
    transactionData = {
        from: fromAddress,
        to: toAddress,
        value: money,
        gasPrice: gasPrice,
        data: '0x00',//当使用代币转账或者合约调用时
        nonce: nonce,
        gas:gas,
    };
    console.log(transactionData);
    responseData.data = transactionData;
    ctx.body = responseData;

};

创建一笔交易，返回交易的gas和gasPrice供用户确认

//确认交易
/*
* 1、签名交易
* 2、发送交易
* */
sendTransaction = async(ctx)=> {

    console.log("sendTransaction");

    var responseData = new response(0, "success", {});
    var body = ctx.request.body;
    var transactionData = {
        from: body.from,
        to: body.to,
        value: body.value,
        gasPrice: body.gasPrice,
        data: body.data,//当使用代币转账或者合约调用时
        nonce: body.nonce,
        gas: body.gas
    };
    //privateKey为了安全,需要进行加密处理
    var privateKey = body.privateKey;
    //签名交易
    console.log(transactionData);
    console.log(privateKey);
    var signTransactionData = await web3.eth.accounts.signTransaction(transactionData, privateKey);
    try {
        //发送交易
        await web3.eth.sendSignedTransaction(signTransactionData.rawTransaction, (error, hash)=> {
            if (!error) {
                responseData.data.hash = hash;
            } else {
                responseData.code = 1;
                responseData.message = "failed";
                responseData.data = {error: error.message};
            }
        })
    } catch (error) {
        console.log(error);
        responseData.code = 1;
        responseData.message = "failed";
        responseData.data = {error: error.message};
    }
    ctx.body = responseData
};

确认一笔交易，这里才是真正提交一笔交易，这时不会直接返回结果，交易提交后，如果连接的是测试链，需要自己去挖矿,执行命令miner.start(),直到矿工确认这笔交易后，才会返回交易信息。如果是测试链，因为它有自己的生态，不需要做其他操作。

//根据txHash查询交易状态
transactionStatus = async(ctx)=> {
  var responseData = new response(0,"success",{});
    var data = ctx.request.body;
    var txHash = data.txHash;
    var result = await web3.eth.getTransactionReceipt(txHash);
    if (result != null){
        responseData.data = result;
    }
    ctx.body = responseData;
};
module.exports = {
    createTransaction,
    sendTransaction,
    transactionStatus,
};

根据交易hash，返回

注：createTransaction方法中调用estimateGas()方法会将transactionData数据做一些操作,导致,transactionData一些值的类型变化,所以下面对transactionData重新赋值

demo下载 https://github.com/sweetMegan/myWalletDemo

`myWallet`为nodejs后台

`myWalletClient`为iOS前端

Nodejs框架Koa

Sat, 14 Jul 2018 00:00:00 +0800

安装环境

安装Node与npm

安装Node.js

brew install node@8

安装指定版本的npm

npm install npm@5.6.0 -g

检查Node版本

node -v

检查npm版本

npm -v

升级Node

npm install -g n

一、Koa

安装Koa

新建一个项目koademo，打开终端

mkdir koademo cd koademo npm init

此时会要求输入一些配置信息，什么都不用写，一直回车

此时项目路径下会新增文件package.json

安装koa

npm install koa

新建index.js文件，添加如下代码,开启服务,监听端口3000

const Koa = require("koa");
const app = new Koa();
//开启服务,监听端口3000
app.listen(3000);

new Koa():创建的对象被称为Koa应用对象。应用对象时带有node http服务的Koa接口，它可以处理中间件的注册，将http请求分发到中间件，进行默认错误处理，以及对上下文，请求和响应对象进行配置。 app.listen(3000):用于启动一个服务的快捷方法，是对http.createServer的简单包装，它实际上这样运行:http:createServer(app.callback()).listen(3000);

context

context是一个请求的上下文，该对象封装了一个传入的http消息，context有request和response属性，我们可以设置两个属性来处理和响应不同的请求。

代码

const Koa = require("koa");
const app = new Koa();
//开启服务,监听端口3000
app.use((ctx,next)=>{
   ctx.response.body="hello world";
});
app.listen(3000);

说明

app.use(function):将给定的function当做中间件加载到应用中。 ctx:每一个请求都会创建一段上下文，在控制业务逻辑的中间件中，上下文被寄存在ctx对象中。为了使用方便，许多上下文属性和方法都被委托代理到他们的ctx.request和ctx.response，比如访问ctx.type和ctx.length将被代理到response对象,ctx.path和ctx.method将被代理到request对象。

启动服务

node index.js

浏览器访问 http://localhost:3000,如果运行正确，在页面会显示hello world。

三、网页模板

实际开发中，返回给用户的网页往往都写成模板文件。我们可以让Koa先读取模板文件,然后将这个模板返回给用户。

代码

 const Koa = require("koa");
const app = new Koa();
const fs = require("fs");
app.use((ctx,next)=>{
    //必须指定type,否则调用fs模板后默认响应类型为为`application/octet-stream`类型
    ctx.response.type="text/html";
    //将文件作为响应体流失传输
    ctx.response.body=fs.createReadStream("./views/index.html");
});
app.listen("3000");

四、中间件

Koa所有的功能都是通过中间件实现的。中间件处在HTTP Request和HTTP Response中间

Koa的中间件之间按照编码顺序在栈内一次执行，允许您执行操作并向下传递请求，之后过滤并逆序返回响应。

const Koa = require('koa');
const app = new Koa();

app.use(async (ctx,next)=>{
    console.log("first");
    await next();
    console.log("first over")
});
app.use(async(ctx,next)=>{
   console.log("second");
    await next();
    console.log("second over")

});
app.use(async(ctx,next)=>{
    console.log("third");
    await next();
console.log("third over");
});

有async标记的函数称为异步函数，在异步函数中，可以用await调用另一个异步函数。使用await时，它所在的方法必须使用关键字async。

执行结果:

first

second

third

third over

second over

first over

五、原生路由

开发中需要根据用户请求返回相应的数据，可以通过设置路由实现

代码

const Koa = require("koa");
const app = new Koa();
app.use(async (ctx)=>{
    if (ctx.request.path=="/"){
        ctx.response.body = "首页";
    }
    switch (ctx.request.path){
        case "/":{
            ctx.response.body = "首页";
            break;
        }
        case "/login":{
            ctx.body = "login";
            break;
        }
        case "/test":{
            ctx.body = "test";
            break;
        }
        
    }
});
//开启服务,监听端口3000
app.listen(3000);

浏览器访问	结果
http://localhost:3000/	首页
http://localhost:3000/login	login
http://localhost:3000/test	test

六、koa-router

原生路由用起来不方便，我们可以使用封装好的koa-router模块

npm install koa-router

代码

const Koa = require("koa");
const app = new Koa();
const r = require("koa-router");
const router = r();
//设置路由
router.get("/",(ctx,next)=>{
    ctx.body = "首页";

});
router.get("/login",(ctx,next)=>{
    ctx.body = "login";

});
router.get("/test",(ctx,next)=>{
    ctx.body = "test";
});
//绑定路由
app.use(router.routes());
//开启服务,监听端口3000
app.listen(3000);

七、重定向

将上面的代码中test重定向到login

const Koa = require("koa");
const app = new Koa();
const r = require("koa-router");
const router = r();
//设置路由
router.get("/",(ctx,next)=>{
    ctx.body = "首页";

});
router.get("/login",(ctx,next)=>{
    ctx.body = "login";

});
//test重定向到login
router.get("/test",(ctx,next)=>{
    ctx.response.redirect("/login");
});
//绑定路由
app.use(router.routes());
//开启服务,监听端口3000
app.listen(3000);

八、获取get请求参数

/**
 * Created by zhqmac on 2018/7/22.
 */
const Koa = require("koa");
const app = new Koa();
const router= require("koa-router")();
app.use((ctx,next)=>{
   console.log(ctx.request.method);
    console.log(ctx.request.url);
    next()
});
//http://localhost:3000/login?name=zhq?age=26
router.get("/login",ctx=>{
   var name = ctx.query.name;
    var age = ctx.query.age;
    console.log(name+"年龄:"+age);
    ctx.body = `<h1> Hello,${name}</h1>`
});
//http://localhost:3000/regist/zhq/26
router.get("/regist/:name/:age",ctx=>{
    var name = ctx.params.name;
    var age = ctx.params.age;
    ctx.response.body = `<h1>regist, ${name} ${age}!</h1>`;


});
app.use(router.routes());
//开启服务,监听端口3000
app.listen(3000);

获取post请求参数

const Koa = require("koa");
const app = new Koa();
const koaBody = require("koa-body");

const router= require("koa-router")();
app.use(async (ctx,next)=>{
    console.log(ctx.request.method);
    console.log(ctx.request.url);
    await next()
});
router.post("/login", (ctx,next) => {
    var body = ctx.request.body;
    console.log(body);
    console.log(body.name);
    ctx.body = {name:body.name};

});
app.use(koaBody());
app.use(router.routes());
//开启服务,监听端口3000
app.listen(3000);

使用curl发起post请求

curl -X POST –data “name=zhq” 127.0.0.1:3000/login

返回结果是一个json串

{
    "name": "zhq"
}

十、加载静态资源

如图片、字体、样式表、脚本等

引入koa-static

npm install koa-static

下面以加载一张图片为例

新建目录static
在static目录下新建images目录
在images目录下添加一张图片avatar.JPG

代码

const Koa = require("koa");
const app = new Koa();
const path = require("path");
const koaStatic= require("koa-static");
const router= require("koa-router")();

//静态资源目录对于相对入口文件的路径
const staticPath = './static';

router.get("/",ctx=>{
   ctx.body = "<html><a href='/images/avatar.JPG'>点我</a></html>"
});
app.use(koaStatic(
    path.join(__dirname,staticPath)
));
app.use(router.routes());
//开启服务,监听端口3000
app.listen(3000);

十一、模板引擎

安装ejs模板引擎

npm install ejs npm install koa-views

代码

const Koa = require("koa");
const app = new Koa();
//引入koa-router的时候要加上一个()
var router = require("koa-router")();
var views = require("koa-views");
var path = require("path");
//views 必须是异步才可以
router.get("/login",async ctx=>{
    //将json里面的值替换为文件里面的变量
    //go 里面使用的是template模板,他们功能类型
    var name = "zhq";
    await ctx.render("loginEjs.ejs",{
        name
    })
});
router.get("/regist",async ctx=>{
    await ctx.render("regist.html")
});
app.use(views(
    path.join(__dirname,"./views"),
    {
        extensions:"ejs",
        //默认去views下面获取ejs后缀的文件
        //如果是其他类型的文件需要制定文件类型
        map:{
            html:"ejs"
        }
    }
));
//路由注册到中间件
app.use(router.routes());
//开启服务,监听端口3000
app.listen(3000);

loginEjs.js

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        div{
            background: darkcyan;
        }
    </style>
</head>
<body>
<div>注册  <%=  name %></div>
</body>
</html>

源码下载 https://github.com/sweetMegan/koaDemo

感谢李旭（旭哥）指导

Nodejs实现以太坊钱包-概述

Sat, 14 Jul 2018 00:00:00 +0800

􏰲􏰳􏰴􏰩􏰵􏰶􏰷􏰸􏰹􏰬􏰺􏰻􏰼􏰽􏰾􏰲􏰳􏰴􏰩􏰵􏰶􏰷􏰸􏰹􏰬􏰺􏰻􏰼􏰽􏰾􏰲􏰳􏰴􏰩􏰵􏰶􏰷􏰸􏰹􏰬􏰺􏰻􏰼􏰽􏰾􏰲􏰳􏰴􏰩􏰵􏰶􏰷􏰸􏰹􏰬 如何做一个功能完整的以太坊钱包？以太坊官方提供了一些API()给开发者使用，但是依靠这些API不足以做成一个完整功能的钱包。主要在转账这块，由于安全性考虑，在加解密，数字签名这块不可能有现成的API暴露给开发者。官方给了一个Nodejs的模块给我们使用，叫web3。

web3

web3模块主要连接以太坊暴露出来的RPC层。开发者利用web3连接RPC层，可以连接任何暴露了RPC接口的节点，从而与区块链交互。

web3中有eth对象-web.eth具体来表示与以太坊区块链和智能合约之间的交互。web3.util有一些辅助函数。另外还有shh和bzz用于通信和文件存储的对象。

github地址：web3

文档:web3

Koa

我们的钱包项目使用web3可以与区块链交互了，这个web3是Nodejs的库，那么我们就用nodejs提供后台接口供前端调用即可，这里使用Koa框架。

Koa是富有表现力的HTTP中间件框架，使web应用程序和API更易于编写，他的特点优雅、简洁、表达力强、自由度高。

github地址：Koa

中间件

Koa的最大特色，也是最重要的一个设计，就是中间件。Koa中间件是简单的函数，调用app.use()传入MiddlewareFunction函数带有两个参数(ctx,next)。中间件处在HTTP Request和HTTP Response之间，用来实现某种中间功能。如:

app.use(async (ctx, next) => {
    console.log(`Process ${ctx.request.method} ${ctx.request.url} ...`);
    await next();
});

ctx 是一个请求的上下文，该对象封装了一个传入的http消息，并对该消息进行了相应的响应。Koa提供了一个Request对象作为Context和request属性。Koa的Request对象提供了用于处理http请求的方法。Koa提供了一个Response对象作为Context和response属性。Koa的Response对象提供了用于处理http响应的方法。

next是一个被调用来执行下游中间件的函数，必须手动调用next()以运行下游中间件。

sweetsmelon博客

go gRPC 初体验

安装 gRPC

安装 protocal 环境

goland 安装 protoc 插件

安装GoLang protoc 插件

定义Service

server.go

client.go

添加age字段

一、打开helloworld.proto文件,找到

二、添加响应字段

三、调用

protobuf repeated

package==true

添加方法

demo下载 https://github.com/sweetMegan/gRPCDemo

参考链接：

jwt 初体验

简介

Header

Payload

Signature

如何使用JWT

go 实现myJWT

使用 jwt-go

安装jwt-go

使用

go iris 实现GET、POST、PUT接口

Iris自称是Go语言中所有Web框架最快的，它的特点如下：

使用 iris 实现 REST API

1.不需要传参的GET接口

2.需要传参的GET接口

1.接收的是字符串的处理

2.接收的是JSON数据的处理

1.POST

2.PUT

3.什么是幂等

4.当需要以更新的形式来修改某一具体资源的时候，如何判断用PUT还是POST呢？

demo下载 https://github.com/sweetMegan/irisDemo

go 发送邮件

简述

SMPT

实例

1.导入gomail

2.demo

3.获取授权码,以qq邮箱为例

常用邮箱

参考资料:

go test使用

add.go

add_test.go

测试某个函数

测试单个文件

测试前初始化

参数说明

1、运行参数

2、测试过程控制

参考资料

go defer、panic、recover使用

defer

多个defer调用顺序

defer函数形参的值

defer,return的执行顺序

defer的作用域

panic、recover

panic

参考资料

以太坊私网建立-通过创世区块来初始化区块链

一、创建目录privatechain,名字随便起

二、创建创世块

三、初始化区块链，并且创建一个文件夹来存储区块数据

四、启动私有链节点

五、新建账户

六、挖矿

七、发送交易

八、查看交易

九、查看当前区块总数

十、通过区块号查看区块

十一、交易池状态

一、打开`helloworld.proto`文件,找到

`Header`

`Payload`

`Signature`

安装`jwt-go`

1.不需要传参的`GET`接口

2.需要传参的`GET`接口

2.接收的是`JSON`数据的处理

1.`POST`

2.`PUT`

1.导入`gomail`

一、创建目录`privatechain`,名字随便起

六、实例化`web3`

`myWallet`为nodejs后台

`myWalletClient`为iOS前端